In [ ]:
import matplotlib.pyplot as pl
import numpy as np
import tensorflow as tf
import tensorflow_datasets as tfds
import tensorflow.keras.models as models
import tensorflow.keras.layers as layers
import tensorflow.keras.losses as losses
import tensorflow.keras.optimizers as optimizers
from tensorflow.keras import applications
import requests
from PIL import Image
from io import BytesIO
Data Collection¶
In [ ]:
(ds_train, ds_test), ds_info = tfds.load(
"stanford_dogs",
split = ["train", "test"],
shuffle_files = True,
as_supervised = True,
with_info = True,
)
DS_NUM_OF_CLASSES = 120
DS_TEST_SIZE_50_PERCENT = int(0.5 * 8580)
ds_validation = ds_test.take(DS_TEST_SIZE_50_PERCENT)
ds_test = ds_test.skip(DS_TEST_SIZE_50_PERCENT)
In [ ]:
ds_info
Out[ ]:
In [ ]:
tfds.show_examples(ds_test, ds_info)
Out[ ]:
Preprocessing¶
In [ ]:
PIC_SIZE = 336
AUTOTUNE = tf.data.experimental.AUTOTUNE
BATCH_SIZE = 64
In [ ]:
def normalize_img(image, label):
return tf.cast(image, tf.float32)/255.0, label
def augment_no_noise(image, label):
image = tf.image.resize(image, (PIC_SIZE, PIC_SIZE))
return image, label
def augment_noise(image, label):
image = tf.image.resize(image, (PIC_SIZE, PIC_SIZE))
image = tf.image.random_brightness(image, max_delta = 0.1)
image = tf.image.random_contrast(image, lower = 0.1, upper = 0.2)
image = tf.image.random_flip_left_right(image)
image = tf.image.random_flip_up_down(image)
return image, label
No noise¶
In [ ]:
ds_train_no_noise = ds_train.map(normalize_img, num_parallel_calls=AUTOTUNE)
ds_train_no_noise = ds_train_no_noise.map(augment_no_noise)
ds_train_no_noise = ds_train_no_noise.batch(BATCH_SIZE)
ds_validation_no_noise = ds_validation.map(normalize_img, num_parallel_calls=AUTOTUNE)
ds_validation_no_noise = ds_validation_no_noise.map(augment_no_noise)
ds_validation_no_noise = ds_validation_no_noise.batch(BATCH_SIZE)
ds_test_no_noise = ds_test.map(normalize_img, num_parallel_calls=AUTOTUNE)
ds_test_no_noise = ds_test_no_noise.map(augment_no_noise)
ds_test_no_noise = ds_test_no_noise.batch(BATCH_SIZE)
Noise¶
In [ ]:
ds_train_noise = ds_train.map(normalize_img, num_parallel_calls=AUTOTUNE)
ds_train_noise = ds_train_noise.map(augment_noise)
ds_train_noise = ds_train_noise.batch(BATCH_SIZE)
ds_validation_noise = ds_validation.map(normalize_img, num_parallel_calls=AUTOTUNE)
ds_validation_noise = ds_validation_noise.map(augment_noise)
ds_validation_noise = ds_validation_noise.batch(BATCH_SIZE)
ds_test_noise = ds_test.map(normalize_img, num_parallel_calls=AUTOTUNE)
ds_test_noise = ds_test_noise.map(augment_noise)
ds_test_noise = ds_test_noise.batch(BATCH_SIZE)
Creating the model¶
In [ ]:
LEARNING_RATE = 0.0001
In [ ]:
def build_model(model_name="InceptionV3"):
if model_name == "DenseNet201":
model_part = applications.DenseNet201(include_top=False, input_shape= (PIC_SIZE, PIC_SIZE, 3), weights="imagenet")
model_part.trainable = False
elif model_name=="InceptionV3":
model_part = applications.InceptionV3(include_top= False, input_shape= (PIC_SIZE, PIC_SIZE, 3), weights= 'imagenet')
model = models.Sequential([
model_part,
layers.GlobalAveragePooling2D(),
layers.BatchNormalization(),
layers.Dropout(0.2),
layers.Flatten(),
layers.Dense(DS_NUM_OF_CLASSES, activation='softmax'),
], name=model_name)
model.compile(
loss=losses.SparseCategoricalCrossentropy(),
optimizer=optimizers.Adam(LEARNING_RATE),
metrics=['sparse_categorical_accuracy']
)
print(model.summary())
return model
DenseNet201¶
In [ ]:
denseNet201_model_no_noise = build_model("DenseNet201")
In [ ]:
denseNet201_model_noise = build_model("DenseNet201")
InceptionV3¶
In [ ]:
inceptionV3_model_no_noise = build_model("InceptionV3")
In [ ]:
inceptionV3_model_noise = build_model("InceptionV3")
Training the model¶
In [ ]:
EPOCH_NUM = 10
In [ ]:
def train_model(model, noise_type="No Noise"):
ds_train = ds_train_no_noise if noise_type == "No Noise" else ds_train_noise
ds_validation = ds_validation_no_noise if noise_type == "No Noise" else ds_validation_noise
log = model.fit(
ds_train,
epochs = EPOCH_NUM,
validation_data = ds_validation,
)
train_acc = log.history['sparse_categorical_accuracy'][-1] * 100
val_acc = log.history['val_sparse_categorical_accuracy'][-1] * 100
print("Traning Accuracy = %.2f%%" % train_acc)
print("Validation Accuracy = %.2f%%" % val_acc)
pl.plot(log.history['sparse_categorical_accuracy'])
pl.plot(log.history['val_sparse_categorical_accuracy'])
pl.legend(['Training Accuracy', 'Validation Accuracy'])
pl.grid(True)
pl.title("Model Accuracy")
pl.show()
pl.plot(log.history['loss'])
pl.plot(log.history['val_loss'])
pl.legend(['Training Loss', 'Validation Loss'])
pl.grid(True)
pl.title("Model Loss")
pl.show()
No Noise¶
DenseNet201¶
In [ ]:
train_model(denseNet201_model_no_noise, "No Noise")
InceptionV3¶
In [ ]:
train_model(inceptionV3_model_no_noise, "No Noise")
Noise¶
DenseNet201¶
In [ ]:
train_model(denseNet201_model_noise, "Noise")
InceptionV3¶
In [ ]:
train_model(inceptionV3_model_noise, "Noise")
Testing the model¶
In [ ]:
label_map = [
"Chihuahua",
"Japanese Spaniel",
"Maltese Dog",
"Pekinese",
"Shih-Tzu",
"Blenheim Spaniel",
"Papillion",
"Toy Terrier",
"Rhodesian Ridgeback",
"Afghan Hound",
]
url_map = [
"http://www.dog-learn.com/dog-breeds/chihuahua/images/chihuahua-u1.jpg",
"https://www.dogproductpicker.com/wp-content/uploads/2019/06/Japanese-Chin-Dog-Breed-Information-All-You-Need-To-Know.jpg",
"http://2.bp.blogspot.com/-6sxj3DSKTrY/UHQoywaHI9I/AAAAAAAAAeI/KlK2pqxBrLk/s1600/Maltese_Puppy.jpg",
"https://www.bil-jac.com/media/yhpn5zk4/pekingese-612830804.jpg",
"https://cdn.fotofits.com/petzlover/gallery/img/l/shih-tzu-482537.jpeg",
"https://www.warrenphotographic.co.uk/photography/bigs/18764-Blenheim-Cavalier-King-Charles-Spaniel-pups-white-background.jpg",
"https://i.pinimg.com/originals/66/7e/c5/667ec51548e094fa288212cca22211ba.jpg",
"http://animalsbreeds.com/wp-content/uploads/2014/12/Toy-Manchester-Terrier-6.jpg",
"https://breedadvisor.com/wp-content/uploads/2020/03/rhodesian-ridgeback-gallery.gif",
"https://fishsubsidy.org/wp-content/uploads/2020/01/afghan-hound2.jpg",
]
In [ ]:
url_predict = []
url_images = []
for url in url_map:
response = requests.get(url)
img = np.array(Image.open(BytesIO(response.content)).convert('RGB').resize((PIC_SIZE, PIC_SIZE)))
url_images.append(img)
img = img / 255.0
img = np.expand_dims(img, axis = 0)
url_predict.append(img)
In [ ]:
fig = pl.figure(figsize=(15, 15))
columns = 5
rows = 4
for i in range(len(url_images)):
fig.add_subplot(rows, columns, i + 1)
pl.imshow(url_images[i])
pl.show()
In [ ]:
def test_model(model, noise_type="No Noise"):
ds_test = ds_test_no_noise if noise_type == "No Noise" else ds_test_noise
log = model.evaluate(ds_test)
test_acc = log[-1] * 100
print("Testing Accuracy = %.2f%%" % test_acc)
for i in range(len(url_predict)):
pl.imshow(url_images[i])
pl.show()
guess_arr = model.predict(url_predict[i])
guess_index = np.argmax(guess_arr)
guess_label = "ERROR, OUT OF BOUNDS"
if guess_index < 10:
guess_label = label_map[guess_index]
print("Guess Index:", guess_index)
print("Guess Label:", guess_label)
print("Guess Verdict:", "CORRECT" if guess_index == i else "WRONG")
No Noise¶
DenseNet201¶
In [ ]:
test_model(denseNet201_model_no_noise, "No Noise")
InceptionV3¶
In [ ]:
test_model(inceptionV3_model_no_noise, "No Noise")
Noise¶
DenseNet201¶
In [ ]:
test_model(denseNet201_model_noise, "Noise")
InceptionV3¶
In [ ]:
test_model(inceptionV3_model_noise, "Noise")